home *** CD-ROM | disk | FTP | other *** search
/ World of Video / World of Video.iso / gfxprograms / 3dprograms / rayshade-4.0 / unapplied / mmaloc.patch < prev    next >
Internet Message Format  |  1995-02-13  |  14KB
  1. From theseas!fs.Princeton.EDU!cek Sat, 6 Feb 93 01:37:22 EET
  2. Received: by kriton.UUCP (V1.16/Amiga)
  3.     id AA00000; Sat, 6 Feb 93 01:37:22 EET
  4. Received: by theseas.ntua.gr with UUCP; Wed, 3 Feb 93 02:32:14 +0200
  5. Received: from mcsun.EU.net by pythia.ics.forth.gr via ITEnet with SMTP;
  6.     id AA00647 (5.65c/FORTH-ICS-3.0-MHS-7.0); Wed, 3 Feb 1993 02:26:47 +0200
  7. Received: by mcsun.EU.net via EUnet
  8.     id AA27047 (5.65b/CWI-2.205); Wed, 3 Feb 1993 01:24:36 +0100
  9. Received: from Princeton.EDU by relay2.UU.NET with SMTP 
  10.     (5.61/UUNET-internet-primary) id AA23214; Tue, 2 Feb 93 19:22:40 -0500
  11. Received: from fs.Princeton.EDU by Princeton.EDU (5.65b/2.95/princeton)
  12.     id AA03959; Tue, 2 Feb 93 18:18:11 -0500
  13. Received: by fs.Princeton.EDU (4.1/1.105)
  14.     id AA21112; Tue, 2 Feb 93 18:18:07 EST
  15. Received: from fsa.cpsc.ucalgary.ca by fs.Princeton.EDU (4.1/1.105)
  16.     id AA21011; Tue, 2 Feb 93 18:17:05 EST
  17. Received: from do.cpsc.ucalgary.ca by fsa.cpsc.ucalgary.ca (4.1/CSd1.2)
  18.     id AA01083; Tue, 2 Feb 93 15:23:03 MST
  19. Received: by do.cpsc.ucalgary.ca (4.1/cs1.0)
  20.     id AA23391; Tue, 2 Feb 93 15:23:07 MST
  21. Date: Tue, 2 Feb 93 15:23:03 MST
  22. Message-Id: <9302022223.AA01083@fsa.cpsc.ucalgary.ca>
  23. Errors-To: Princeton.EDU!cek
  24. Remailed-Date: Tue Feb  2 18:17:30 EST 1993
  25. From: cpsc.ucalgary.ca!jamesm (Mark James)
  26. To: cs.Princeton.EDU!rayshade-users
  27. Subject: Gnu mmalloc and rayshade
  28.  
  29. A few of the people in our department are raytracing some fairly
  30. large scenes with rayshade.  For example, a friend of mine has
  31. modeled a field of grass which gives him an 80MB input file. :)  One
  32. problem with this is that rayshade fairly quickly runs out of memory.
  33. :)  However, there is a way around this.  GDB 4.7 has a library
  34. called mmalloc which uses mmap for allocating memory rather than
  35. sbrk.  So now all you need to do is specify the name of a swap file
  36. on a big disk, and rayshade can chew up all the memory it needs.
  37. It's not wonderfully fast, but what can you expect with an 80MB input
  38. file, and at least it gets the job done. :)
  39.  
  40. I've patched rayshade.4.0.6 to use mmalloc.  The patch isn't pretty,
  41. and it doesn't change the Configure script which it really should,
  42. but here it is anyhow.  When Configure asks for C flags, add
  43. "-DMMALLOC", and specify the libmmalloc library when it asks you
  44. about libraries. Please let me know if you have problems with it, or
  45. find it useful.
  46.  
  47.      M.
  48.  
  49. use: patch -p0 -d rayshade.4.0 < mmalloc-patch
  50.  
  51. *** ./libray/libcommon/expr.c    Sun Feb  9 20:04:04 1992
  52. --- ../mrayshade/./libray/libcommon/expr.c    Tue Feb  2 10:47:10 1993
  53. ***************
  54. *** 289,295 ****
  55.   {
  56.       if (!expr->symtab) {
  57.           if (expr->type == BUILTIN_EXPR && expr->params)
  58. !             free((voidstar)expr->params);
  59. !         free((voidstar)expr);
  60.       }
  61.   }
  62. --- 289,295 ----
  63.   {
  64.       if (!expr->symtab) {
  65.           if (expr->type == BUILTIN_EXPR && expr->params)
  66. !             Free((voidstar)expr->params);
  67. !         Free((voidstar)expr);
  68.       }
  69.   }
  70. *** ./libray/libcommon/memory.c    Sun Feb  9 20:03:29 1992
  71. --- ../mrayshade/./libray/libcommon/memory.c    Tue Feb  2 10:47:10 1993
  72. ***************
  73. *** 24,31 ****
  74. --- 24,33 ----
  75.   #include <memory.h>
  76.   #endif
  77.   #include "common.h"
  78. + #include "../../libshade/options.h"
  79.   
  80.   unsigned long TotalAllocated;
  81. + unsigned long TotalDeallocated;
  82.   
  83.   voidstar
  84.   Malloc(bytes)
  85. ***************
  86. *** 33,41 ****
  87.   {
  88.       voidstar res;
  89.   
  90. !     TotalAllocated += bytes;
  91. ! 
  92.       res = (voidstar)malloc(bytes);
  93.       if (res == (voidstar)NULL)
  94.           RLerror(RL_PANIC,
  95.               "Out of memory trying to allocate %d bytes.\n",bytes);
  96. --- 35,45 ----
  97.   {
  98.       voidstar res;
  99.   
  100. ! #ifdef MMALLOC
  101. !     res = (voidstar)mmalloc(Options.mmallocd,bytes);
  102. ! #else
  103.       res = (voidstar)malloc(bytes);
  104. + #endif
  105.       if (res == (voidstar)NULL)
  106.           RLerror(RL_PANIC,
  107.               "Out of memory trying to allocate %d bytes.\n",bytes);
  108. ***************
  109. *** 51,56 ****
  110. --- 55,71 ----
  111.       res = Malloc(nelem*elen);
  112.       bzero(res, (int)nelem*elen);
  113.       return res;
  114. + }
  115. + 
  116. + void
  117. + Free(pointer)
  118. + voidstar pointer;
  119. + {
  120. + #ifdef MMALLOC
  121. +         mfree(Options.mmallocd,pointer);
  122. + #else
  123. +     free(pointer);
  124. + #endif
  125.   }
  126.   
  127.   void
  128. *** ./libray/libcommon/transform.c    Sun Feb  9 20:04:12 1992
  129. --- ../mrayshade/./libray/libcommon/transform.c    Tue Feb  2 10:47:12 1993
  130. ***************
  131. *** 57,64 ****
  132.   Trans *trans;
  133.   {
  134.       if (trans->tr)
  135. !         free((voidstar)trans->tr);
  136. !     free((voidstar)trans);
  137.   }
  138.   
  139.   void
  140. --- 57,64 ----
  141.   Trans *trans;
  142.   {
  143.       if (trans->tr)
  144. !         Free((voidstar)trans->tr);
  145. !     Free((voidstar)trans);
  146.   }
  147.   
  148.   void
  149. *** ./libray/libobj/blob.c    Sun Feb  9 20:04:19 1992
  150. --- ../mrayshade/./libray/libobj/blob.c    Tue Feb  2 10:47:21 1993
  151. ***************
  152. *** 131,137 ****
  153.           blob->list[i].y = cur->mvec.y;
  154.           blob->list[i].z = cur->mvec.z;
  155.           mlist = mlist->next;
  156. !         free((voidstar)cur);
  157.       }
  158.       /* 
  159.        * Allocate room for Intersection Structures and
  160. --- 131,137 ----
  161.           blob->list[i].y = cur->mvec.y;
  162.           blob->list[i].z = cur->mvec.z;
  163.           mlist = mlist->next;
  164. !         Free((voidstar)cur);
  165.       }
  166.       /* 
  167.        * Allocate room for Intersection Structures and
  168. *** ./libray/libobj/geom.c    Sun Feb  9 20:04:11 1992
  169. --- ../mrayshade/./libray/libobj/geom.c    Tue Feb  2 10:47:22 1993
  170. ***************
  171. *** 306,312 ****
  172.       GeomList *ltmp;
  173.   
  174.       ltmp = list->next;    /* Save new head. */
  175. !     free((voidstar)list);    /* Free old head. */
  176.       return ltmp;        /* Return new head. */
  177.   }
  178.   
  179. --- 306,312 ----
  180.       GeomList *ltmp;
  181.   
  182.       ltmp = list->next;    /* Save new head. */
  183. !     Free((voidstar)list);    /* Free old head. */
  184.       return ltmp;        /* Return new head. */
  185.   }
  186.   
  187. *** ./libray/libobj/grid.c    Sun Feb  9 20:04:13 1992
  188. --- ../mrayshade/./libray/libobj/grid.c    Tue Feb  2 10:47:22 1993
  189. ***************
  190. *** 396,402 ****
  191.               for (z = 0; z < grid->zsize; z++) {
  192.                   for (cell = grid->cells[x][y][z]; cell; cell = next) {
  193.                       next = cell->next;
  194. !                     free((voidstar)cell);
  195.                   }
  196.                   grid->cells[x][y][z] = (GeomList *)NULL;
  197.               }
  198. --- 396,402 ----
  199.               for (z = 0; z < grid->zsize; z++) {
  200.                   for (cell = grid->cells[x][y][z]; cell; cell = next) {
  201.                       next = cell->next;
  202. !                     Free((voidstar)cell);
  203.                   }
  204.                   grid->cells[x][y][z] = (GeomList *)NULL;
  205.               }
  206. *** ./libray/libobj/hf.c    Sun Feb  9 20:04:18 1992
  207. --- ../mrayshade/./libray/libobj/hf.c    Tue Feb  2 10:47:22 1993
  208. ***************
  209. *** 210,217 ****
  210.           hitpos.x = ray->pos.x + ray->dir.x * offset;
  211.           hitpos.y = ray->pos.y + ray->dir.y * offset;
  212.           hitpos.z = ray->pos.z + ray->dir.z * offset;
  213. !     } else
  214. !         hitpos = ray->pos;
  215.       /*
  216.        * Find out in which cell "hitpoint" is.
  217.        */
  218. --- 210,216 ----
  219.           hitpos.x = ray->pos.x + ray->dir.x * offset;
  220.           hitpos.y = ray->pos.y + ray->dir.y * offset;
  221.           hitpos.z = ray->pos.z + ray->dir.z * offset;
  222. !     }
  223.       /*
  224.        * Find out in which cell "hitpoint" is.
  225.        */
  226. ***************
  227. *** 509,514 ****
  228. --- 508,515 ----
  229.       tmp2.y = tri->v3.y - tri->v1.y;
  230.       tmp2.z = tri->v3.z - tri->v1.z;
  231.   
  232. +         VecScale(hf->size, tmp1, &tmp1);
  233. +         VecScale(hf->size, tmp2, &tmp2);
  234.       (void)VecNormCross(&tmp1, &tmp2, &tri->norm);
  235.   
  236.       tri->d = -dotp(&tri->v1, &tri->norm);
  237. ***************
  238. *** 657,663 ****
  239.   hfTri *tri;
  240.   {
  241.       if (hf->q[hf->qtail])        /* Free old triangle data */
  242. !         free((voidstar)hf->q[hf->qtail]);
  243.       hf->q[hf->qtail] = tri;        /* Put on tail */
  244.       hf->qtail = (hf->qtail + 1) % hf->qsize;    /* Increment tail */
  245.   }
  246. --- 658,664 ----
  247.   hfTri *tri;
  248.   {
  249.       if (hf->q[hf->qtail])        /* Free old triangle data */
  250. !         Free((voidstar)hf->q[hf->qtail]);
  251.       hf->q[hf->qtail] = tri;        /* Put on tail */
  252.       hf->qtail = (hf->qtail + 1) % hf->qsize;    /* Increment tail */
  253.   }
  254. *** ./libray/libobj/poly.c    Sun Feb  9 20:04:08 1992
  255. --- ../mrayshade/./libray/libobj/poly.c    Tue Feb  2 10:47:22 1993
  256. ***************
  257. *** 67,73 ****
  258.       for(curp = plist; curp != (PointList *)0; curp = pltmp) {
  259.           poly->points[i--] = curp->vec;
  260.           pltmp = curp->next;
  261. !         free((voidstar)curp);
  262.       }
  263.   
  264.       /*
  265. --- 67,73 ----
  266.       for(curp = plist; curp != (PointList *)0; curp = pltmp) {
  267.           poly->points[i--] = curp->vec;
  268.           pltmp = curp->next;
  269. !         Free((voidstar)curp);
  270.       }
  271.   
  272.       /*
  273. ***************
  274. *** 86,92 ****
  275.            * Degenerate normal --> degenerate polygon
  276.            */
  277.           RLerror(RL_WARN, "Degenerate polygon.\n");
  278. !         free((voidstar)poly->points);
  279.           return (Polygon *)NULL;
  280.       }
  281.   
  282. --- 86,92 ----
  283.            * Degenerate normal --> degenerate polygon
  284.            */
  285.           RLerror(RL_WARN, "Degenerate polygon.\n");
  286. !         Free((voidstar)poly->points);
  287.           return (Polygon *)NULL;
  288.       }
  289.   
  290. *** ./libray/libsurf/surface.c    Sun Feb  9 20:03:52 1992
  291. --- ../mrayshade/./libray/libsurf/surface.c    Tue Feb  2 10:47:26 1993
  292. ***************
  293. *** 135,141 ****
  294.   {
  295.       SurfList *stmp = list->next;
  296.   
  297. !     free((voidstar)list);
  298.       return stmp;
  299.   }
  300.   
  301. --- 135,141 ----
  302.   {
  303.       SurfList *stmp = list->next;
  304.   
  305. !     Free((voidstar)list);
  306.       return stmp;
  307.   }
  308.   
  309. *** ./libshade/funcdefs.h    Sun Feb  9 20:03:18 1992
  310. --- ../mrayshade/./libshade/funcdefs.h    Tue Feb  2 10:47:33 1993
  311. ***************
  312. *** 36,42 ****
  313.    * Misc. routines.
  314.    */
  315.   #ifndef I_STDLIB
  316. ! extern void    free(), exit();
  317.   #endif
  318.   
  319.   extern void get_cpu_time(), read_input_file();
  320. --- 36,42 ----
  321.    * Misc. routines.
  322.    */
  323.   #ifndef I_STDLIB
  324. ! extern void    Free(), exit();
  325.   #endif
  326.   
  327.   extern void get_cpu_time(), read_input_file();
  328. *** ./libshade/misc.c    Sun Feb  9 20:03:59 1992
  329. --- ../mrayshade/./libshade/misc.c    Tue Feb  2 10:47:33 1993
  330. ***************
  331. *** 37,42 ****
  332. --- 37,46 ----
  333.   #include "options.h"
  334.   #include "stats.h"
  335.   
  336. + #ifdef MMALLOC
  337. + #include <fcntl.h>
  338. + #endif
  339. + 
  340.   Float RSabstmp;    /* Temporary value used by fabs macro.  Ugly. */
  341.   static void RSmessage();
  342.   
  343. ***************
  344. *** 103,108 ****
  345. --- 107,135 ----
  346.               "Cannot open stats file %s.\n", Options.statsname);
  347.       }
  348.   }
  349. + 
  350. + #ifdef MMALLOC
  351. + void
  352. + InitMMalloc()
  353. + {
  354. +     int fd;
  355. +     if (Options.mmapname == (char *)NULL)
  356. +         return;        /* Not specified or already opened. */
  357. + 
  358. +     fd = open(Options.mmapname, (O_CREAT | O_RDWR), 0600);
  359. +     unlink(Options.mmapname);
  360. +     if (fd < 0) {
  361. +         RLerror(RL_PANIC,
  362. +             "Cannot open mmalloc file %s.\n", Options.statsname);
  363. +     }
  364. +     Options.mmallocd=(voidstar)mmalloc_attach(fd,0xE0000000);  /* 0xE... is a hack from GDB 4.7  */
  365. +     if(Options.mmallocd==0){
  366. +         RLerror(RL_PANIC,
  367. +             "Mmalloc_attatch failed!\n");
  368. +     }
  369. +     
  370. + }
  371. + #endif
  372.   
  373.   void
  374.   RLerror(level, pat, arg1, arg2, arg3)
  375. *** ./libshade/options.c    Sun Feb  9 20:04:09 1992
  376. --- ../mrayshade/./libshade/options.c    Tue Feb  2 10:47:33 1993
  377. ***************
  378. *** 137,142 ****
  379. --- 137,157 ----
  380.                   Options.samplemap = !Options.samplemap;
  381.                   break;
  382.   #endif
  383. + #ifdef MMALLOC
  384. +             case 'M':
  385. +                 if (argv[1][0] == '-') {
  386. +                     /* User probably blew it, and
  387. +                      * it's difficult to remove a file
  388. +                      * that begins with '-'...
  389. +                      */
  390. +                     usage();
  391. +                     exit(2);
  392. +                 }
  393. +                 Options.mmapname = strsave(argv[1]);
  394. +                 InitMMalloc();
  395. +                 argv++; argc--;
  396. +                 break;
  397. + #endif                
  398.               case 'N':
  399.                   Options.totalframes = atof(argv[1]);
  400.                   Options.totalframes_set = TRUE;
  401. ***************
  402. *** 317,322 ****
  403. --- 332,340 ----
  404.       fprintf(stderr,"\t-l \t\t(Render image for left eye view.)\n");
  405.   #ifdef URT
  406.       fprintf(stderr,"\t-m \t\t(Output sample map in alpha channel.)\n");
  407. + #endif
  408. + #ifdef MMALLOC
  409. +     fprintf(stderr,"\t-M filename \t(Use filename for swapping.)\n");
  410.   #endif
  411.       fprintf(stderr,"\t-N number\t(Render given number of frames.)\n");
  412.       fprintf(stderr,"\t-n \t\t(Do not render shadows.)\n");
  413. *** ./libshade/options.h    Sun Feb  9 20:03:53 1992
  414. --- ../mrayshade/./libshade/options.h    Tue Feb  2 10:47:33 1993
  415. ***************
  416. *** 74,79 ****
  417. --- 74,83 ----
  418.       int    alpha;            /* Write alpha channel? */
  419.       int    exp_output;        /* Write exponential RLE file? */
  420.   #endif
  421. + #ifdef MMALLOC
  422. +     char * mmapname;
  423. +     void * mmallocd;
  424. + #endif
  425.       Float    eyesep,            /* Eye separation (for Stereo mode) */
  426.           gamma,            /* Gamma value (0 == no correction) */
  427.           starttime,        /* Think about it ... */
  428. *** ./libshade/shade.c    Sun Feb  9 20:04:12 1992
  429. --- ../mrayshade/./libshade/shade.c    Tue Feb  2 10:47:34 1993
  430. ***************
  431. *** 343,349 ****
  432.           ColorAdd(*color, newcol, color);
  433.           /* Free pushed medium */
  434.           if (enter)
  435. !             free((voidstar)NewRay.media);
  436.       }
  437.   
  438.       return total_int_refl;
  439. --- 343,349 ----
  440.           ColorAdd(*color, newcol, color);
  441.           /* Free pushed medium */
  442.           if (enter)
  443. !             Free((voidstar)NewRay.media);
  444.       }
  445.   
  446.       return total_int_refl;
  447. *** ./libshade/yacc.y    Sun Feb  9 20:04:21 1992
  448. --- ../mrayshade/./libshade/yacc.y    Tue Feb  2 10:47:35 1993
  449. ***************
  450. *** 537,543 ****
  451.                * Eye can be transformed...
  452.               if (CurMatrix) {
  453.                   PointTransform(&Camera.pos, CurMatrix);
  454. !                 free((voidstar)CurMatrix);
  455.                   CurMatrix = (Matrix*)NULL;
  456.               }
  457.                */
  458. --- 537,543 ----
  459.                * Eye can be transformed...
  460.               if (CurMatrix) {
  461.                   PointTransform(&Camera.pos, CurMatrix);
  462. !                 Free((voidstar)CurMatrix);
  463.                   CurMatrix = (Matrix*)NULL;
  464.               }
  465.                */
  466. ***************
  467. *** 806,812 ****
  468.                * converted from 3.0, surfnames this can account
  469.                * for lots o' bytes.
  470.                */
  471. !             free((voidstar)$1);
  472.           }
  473.           | tCURSURF
  474.           {
  475. --- 806,812 ----
  476.                * converted from 3.0, surfnames this can account
  477.                * for lots o' bytes.
  478.                */
  479. !             Free((voidstar)$1);
  480.           }
  481.           | tCURSURF
  482.           {
  483. *** ./raypaint/render.c    Sun Feb  9 20:04:20 1992
  484. --- ../mrayshade/./raypaint/render.c    Tue Feb  2 10:47:40 1993
  485. ***************
  486. *** 232,238 ****
  487.           PictureWriteLine(pixelbuf);
  488.       }
  489.       PictureEnd();
  490. !     free((voidstar)pixelbuf);
  491.   }
  492.   
  493.   Float
  494. --- 232,238 ----
  495.           PictureWriteLine(pixelbuf);
  496.       }
  497.       PictureEnd();
  498. !     Free((voidstar)pixelbuf);
  499.   }
  500.   
  501.   Float
  502. *** ./rayview/spheregen.c    Sun Feb  9 20:04:07 1992
  503. --- ../mrayshade/./rayview/spheregen.c    Tue Feb  2 10:47:42 1993
  504. ***************
  505. *** 204,211 ****
  506.       }
  507.   
  508.       if (level > 1) {
  509. !         free(old->poly);
  510. !         free(old);
  511.       }
  512.   
  513.       /* Continue subdividing new triangles */
  514. --- 204,211 ----
  515.       }
  516.   
  517.       if (level > 1) {
  518. !         Free(old->poly);
  519. !         Free(old);
  520.       }
  521.   
  522.       /* Continue subdividing new triangles */
  523.  
  524. ----------
  525. Administrivia: rayshade-request@cs.princeton.edu
  526. Mailing list: rayshade-users@cs.princeton.edu
  527.  
  528.